home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_binop.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  12KB  |  397 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. '''Tests for binary operators on subtypes of built-in types.'''
  5. import unittest
  6. from test import test_support
  7.  
  8. def gcd(a, b):
  9.     """Greatest common divisor using Euclid's algorithm."""
  10.     while a:
  11.         a = b % a
  12.         b = a
  13.     return b
  14.  
  15.  
  16. def isint(x):
  17.     '''Test whether an object is an instance of int or long.'''
  18.     if not isinstance(x, int):
  19.         pass
  20.     return isinstance(x, long)
  21.  
  22.  
  23. def isnum(x):
  24.     '''Test whether an object is an instance of a built-in numeric type.'''
  25.     for T in (int, long, float, complex):
  26.         if isinstance(x, T):
  27.             return 1
  28.             continue
  29.     
  30.     return 0
  31.  
  32.  
  33. def isRat(x):
  34.     '''Test wheter an object is an instance of the Rat class.'''
  35.     return isinstance(x, Rat)
  36.  
  37.  
  38. class Rat(object):
  39.     '''Rational number implemented as a normalized pair of longs.'''
  40.     __slots__ = [
  41.         '_Rat__num',
  42.         '_Rat__den']
  43.     
  44.     def __init__(self, num = 0x0L, den = 0x1L):
  45.         '''Constructor: Rat([num[, den]]).
  46.  
  47.         The arguments must be ints or longs, and default to (0, 1).'''
  48.         if not isint(num):
  49.             raise TypeError, 'Rat numerator must be int or long (%r)' % num
  50.         
  51.         if not isint(den):
  52.             raise TypeError, 'Rat denominator must be int or long (%r)' % den
  53.         
  54.         if den == 0:
  55.             raise ZeroDivisionError, 'zero denominator'
  56.         
  57.         g = gcd(den, num)
  58.         self._Rat__num = long(num // g)
  59.         self._Rat__den = long(den // g)
  60.  
  61.     
  62.     def _get_num(self):
  63.         """Accessor function for read-only 'num' attribute of Rat."""
  64.         return self._Rat__num
  65.  
  66.     num = property(_get_num, None)
  67.     
  68.     def _get_den(self):
  69.         """Accessor function for read-only 'den' attribute of Rat."""
  70.         return self._Rat__den
  71.  
  72.     den = property(_get_den, None)
  73.     
  74.     def __repr__(self):
  75.         '''Convert a Rat to an string resembling a Rat constructor call.'''
  76.         return 'Rat(%d, %d)' % (self._Rat__num, self._Rat__den)
  77.  
  78.     
  79.     def __str__(self):
  80.         '''Convert a Rat to a string resembling a decimal numeric value.'''
  81.         return str(float(self))
  82.  
  83.     
  84.     def __float__(self):
  85.         '''Convert a Rat to a float.'''
  86.         return self._Rat__num * 1.0 / self._Rat__den
  87.  
  88.     
  89.     def __int__(self):
  90.         '''Convert a Rat to an int; self.den must be 1.'''
  91.         if self._Rat__den == 1:
  92.             
  93.             try:
  94.                 return int(self._Rat__num)
  95.             except OverflowError:
  96.                 raise OverflowError, '%s too large to convert to int' % repr(self)
  97.             except:
  98.                 None<EXCEPTION MATCH>OverflowError
  99.             
  100.  
  101.         None<EXCEPTION MATCH>OverflowError
  102.         raise ValueError, "can't convert %s to int" % repr(self)
  103.  
  104.     
  105.     def __long__(self):
  106.         '''Convert a Rat to an long; self.den must be 1.'''
  107.         if self._Rat__den == 1:
  108.             return long(self._Rat__num)
  109.         
  110.         raise ValueError, "can't convert %s to long" % repr(self)
  111.  
  112.     
  113.     def __add__(self, other):
  114.         '''Add two Rats, or a Rat and a number.'''
  115.         if isint(other):
  116.             other = Rat(other)
  117.         
  118.         if isRat(other):
  119.             return Rat(self._Rat__num * other._Rat__den + other._Rat__num * self._Rat__den, self._Rat__den * other._Rat__den)
  120.         
  121.         if isnum(other):
  122.             return float(self) + other
  123.         
  124.         return NotImplemented
  125.  
  126.     __radd__ = __add__
  127.     
  128.     def __sub__(self, other):
  129.         '''Subtract two Rats, or a Rat and a number.'''
  130.         if isint(other):
  131.             other = Rat(other)
  132.         
  133.         if isRat(other):
  134.             return Rat(self._Rat__num * other._Rat__den - other._Rat__num * self._Rat__den, self._Rat__den * other._Rat__den)
  135.         
  136.         if isnum(other):
  137.             return float(self) - other
  138.         
  139.         return NotImplemented
  140.  
  141.     
  142.     def __rsub__(self, other):
  143.         '''Subtract two Rats, or a Rat and a number (reversed args).'''
  144.         if isint(other):
  145.             other = Rat(other)
  146.         
  147.         if isRat(other):
  148.             return Rat(other._Rat__num * self._Rat__den - self._Rat__num * other._Rat__den, self._Rat__den * other._Rat__den)
  149.         
  150.         if isnum(other):
  151.             return other - float(self)
  152.         
  153.         return NotImplemented
  154.  
  155.     
  156.     def __mul__(self, other):
  157.         '''Multiply two Rats, or a Rat and a number.'''
  158.         if isRat(other):
  159.             return Rat(self._Rat__num * other._Rat__num, self._Rat__den * other._Rat__den)
  160.         
  161.         if isint(other):
  162.             return Rat(self._Rat__num * other, self._Rat__den)
  163.         
  164.         if isnum(other):
  165.             return float(self) * other
  166.         
  167.         return NotImplemented
  168.  
  169.     __rmul__ = __mul__
  170.     
  171.     def __truediv__(self, other):
  172.         '''Divide two Rats, or a Rat and a number.'''
  173.         if isRat(other):
  174.             return Rat(self._Rat__num * other._Rat__den, self._Rat__den * other._Rat__num)
  175.         
  176.         if isint(other):
  177.             return Rat(self._Rat__num, self._Rat__den * other)
  178.         
  179.         if isnum(other):
  180.             return float(self) / other
  181.         
  182.         return NotImplemented
  183.  
  184.     __div__ = __truediv__
  185.     
  186.     def __rtruediv__(self, other):
  187.         '''Divide two Rats, or a Rat and a number (reversed args).'''
  188.         if isRat(other):
  189.             return Rat(other._Rat__num * self._Rat__den, other._Rat__den * self._Rat__num)
  190.         
  191.         if isint(other):
  192.             return Rat(other * self._Rat__den, self._Rat__num)
  193.         
  194.         if isnum(other):
  195.             return other / float(self)
  196.         
  197.         return NotImplemented
  198.  
  199.     __rdiv__ = __rtruediv__
  200.     
  201.     def __floordiv__(self, other):
  202.         '''Divide two Rats, returning the floored result.'''
  203.         if isint(other):
  204.             other = Rat(other)
  205.         elif not isRat(other):
  206.             return NotImplemented
  207.         
  208.         x = self / other
  209.         return x._Rat__num // x._Rat__den
  210.  
  211.     
  212.     def __rfloordiv__(self, other):
  213.         '''Divide two Rats, returning the floored result (reversed args).'''
  214.         x = other / self
  215.         return x._Rat__num // x._Rat__den
  216.  
  217.     
  218.     def __divmod__(self, other):
  219.         '''Divide two Rats, returning quotient and remainder.'''
  220.         if isint(other):
  221.             other = Rat(other)
  222.         elif not isRat(other):
  223.             return NotImplemented
  224.         
  225.         x = self // other
  226.         return (x, self - other * x)
  227.  
  228.     
  229.     def __rdivmod__(self, other):
  230.         '''Divide two Rats, returning quotient and remainder (reversed args).'''
  231.         if isint(other):
  232.             other = Rat(other)
  233.         elif not isRat(other):
  234.             return NotImplemented
  235.         
  236.         return divmod(other, self)
  237.  
  238.     
  239.     def __mod__(self, other):
  240.         '''Take one Rat modulo another.'''
  241.         return divmod(self, other)[1]
  242.  
  243.     
  244.     def __rmod__(self, other):
  245.         '''Take one Rat modulo another (reversed args).'''
  246.         return divmod(other, self)[1]
  247.  
  248.     
  249.     def __eq__(self, other):
  250.         '''Compare two Rats for equality.'''
  251.         if isint(other):
  252.             if self._Rat__den == 1:
  253.                 pass
  254.             return self._Rat__num == other
  255.         
  256.         if isRat(other):
  257.             if self._Rat__num == other._Rat__num:
  258.                 pass
  259.             return self._Rat__den == other._Rat__den
  260.         
  261.         if isnum(other):
  262.             return float(self) == other
  263.         
  264.         return NotImplemented
  265.  
  266.     
  267.     def __ne__(self, other):
  268.         '''Compare two Rats for inequality.'''
  269.         return not (self == other)
  270.  
  271.  
  272.  
  273. class RatTestCase(unittest.TestCase):
  274.     '''Unit tests for Rat class and its support utilities.'''
  275.     
  276.     def test_gcd(self):
  277.         self.assertEqual(gcd(10, 12), 2)
  278.         self.assertEqual(gcd(10, 15), 5)
  279.         self.assertEqual(gcd(10, 11), 1)
  280.         self.assertEqual(gcd(100, 15), 5)
  281.         self.assertEqual(gcd(-10, 2), -2)
  282.         self.assertEqual(gcd(10, -2), 2)
  283.         self.assertEqual(gcd(-10, -2), -2)
  284.         for i in range(1, 20):
  285.             for j in range(1, 20):
  286.                 self.assert_(gcd(i, j) > 0)
  287.                 self.assert_(gcd(-i, j) < 0)
  288.                 self.assert_(gcd(i, -j) > 0)
  289.                 self.assert_(gcd(-i, -j) < 0)
  290.             
  291.         
  292.  
  293.     
  294.     def test_constructor(self):
  295.         a = Rat(10, 15)
  296.         self.assertEqual(a.num, 2)
  297.         self.assertEqual(a.den, 3)
  298.         a = Rat(0xAL, 0xFL)
  299.         self.assertEqual(a.num, 2)
  300.         self.assertEqual(a.den, 3)
  301.         a = Rat(10, -15)
  302.         self.assertEqual(a.num, -2)
  303.         self.assertEqual(a.den, 3)
  304.         a = Rat(-10, 15)
  305.         self.assertEqual(a.num, -2)
  306.         self.assertEqual(a.den, 3)
  307.         a = Rat(-10, -15)
  308.         self.assertEqual(a.num, 2)
  309.         self.assertEqual(a.den, 3)
  310.         a = Rat(7)
  311.         self.assertEqual(a.num, 7)
  312.         self.assertEqual(a.den, 1)
  313.         
  314.         try:
  315.             a = Rat(1, 0)
  316.         except ZeroDivisionError:
  317.             pass
  318.  
  319.         self.fail("Rat(1, 0) didn't raise ZeroDivisionError")
  320.         for bad in ('0', 0.0, (0.0+0.0j), (), [], { }, None, Rat, unittest):
  321.             
  322.             try:
  323.                 a = Rat(bad)
  324.             except TypeError:
  325.                 pass
  326.  
  327.             self.fail("Rat(%r) didn't raise TypeError" % bad)
  328.             
  329.             try:
  330.                 a = Rat(1, bad)
  331.             except TypeError:
  332.                 continue
  333.  
  334.             self.fail("Rat(1, %r) didn't raise TypeError" % bad)
  335.         
  336.  
  337.     
  338.     def test_add(self):
  339.         self.assertEqual(Rat(2, 3) + Rat(1, 3), 1)
  340.         self.assertEqual(Rat(2, 3) + 1, Rat(5, 3))
  341.         self.assertEqual(1 + Rat(2, 3), Rat(5, 3))
  342.         self.assertEqual(1.0 + Rat(1, 2), 1.5)
  343.         self.assertEqual(Rat(1, 2) + 1.0, 1.5)
  344.  
  345.     
  346.     def test_sub(self):
  347.         self.assertEqual(Rat(7, 2) - Rat(7, 5), Rat(21, 10))
  348.         self.assertEqual(Rat(7, 5) - 1, Rat(2, 5))
  349.         self.assertEqual(1 - Rat(3, 5), Rat(2, 5))
  350.         self.assertEqual(Rat(3, 2) - 1.0, 0.5)
  351.         self.assertEqual(1.0 - Rat(1, 2), 0.5)
  352.  
  353.     
  354.     def test_mul(self):
  355.         self.assertEqual(Rat(2, 3) * Rat(5, 7), Rat(10, 21))
  356.         self.assertEqual(Rat(10, 3) * 3, 10)
  357.         self.assertEqual(3 * Rat(10, 3), 10)
  358.         self.assertEqual(Rat(10, 5) * 0.5, 1.0)
  359.         self.assertEqual(0.5 * Rat(10, 5), 1.0)
  360.  
  361.     
  362.     def test_div(self):
  363.         self.assertEqual(Rat(10, 3) / Rat(5, 7), Rat(14, 3))
  364.         self.assertEqual(Rat(10, 3) / 3, Rat(10, 9))
  365.         self.assertEqual(2 / Rat(5), Rat(2, 5))
  366.         self.assertEqual(3.0 * Rat(1, 2), 1.5)
  367.         self.assertEqual(Rat(1, 2) * 3.0, 1.5)
  368.  
  369.     
  370.     def test_floordiv(self):
  371.         self.assertEqual(Rat(10) // Rat(4), 2)
  372.         self.assertEqual(Rat(10, 3) // Rat(4, 3), 2)
  373.         self.assertEqual(Rat(10) // 4, 2)
  374.         self.assertEqual(10 // Rat(4), 2)
  375.  
  376.     
  377.     def test_eq(self):
  378.         self.assertEqual(Rat(10), Rat(20, 2))
  379.         self.assertEqual(Rat(10), 10)
  380.         self.assertEqual(10, Rat(10))
  381.         self.assertEqual(Rat(10), 10.0)
  382.         self.assertEqual(10.0, Rat(10))
  383.  
  384.     
  385.     def test_future_div(self):
  386.         exec future_test
  387.  
  388.  
  389. future_test = "\nfrom __future__ import division\nself.assertEqual(Rat(10, 3) / Rat(5, 7), Rat(14, 3))\nself.assertEqual(Rat(10, 3) / 3, Rat(10, 9))\nself.assertEqual(2 / Rat(5), Rat(2, 5))\nself.assertEqual(3.0 * Rat(1, 2), 1.5)\nself.assertEqual(Rat(1, 2) * 3.0, 1.5)\nself.assertEqual(eval('1/2'), 0.5)\n"
  390.  
  391. def test_main():
  392.     test_support.run_unittest(RatTestCase)
  393.  
  394. if __name__ == '__main__':
  395.     test_main()
  396.  
  397.